// Copyright (c) Microsoft Corporation.  All rights reserved.

#pragma once

namespace Microsoft { namespace WindowsAPICodePack { namespace DirectX { namespace Direct2D1 {

/// <summary>
/// Differentiates which of the two possible arcs could match the given arc parameters.
/// <para>(Also see DirectX SDK: D2D1_ARC_SIZE)</para>
///</summary>
public enum class ArcSize : Int32
{
    Small = D2D1_ARC_SIZE_SMALL,
    Large = D2D1_ARC_SIZE_LARGE,
};

/// <summary>
/// Specifies how simple the output of a simplified geometry sink should be.
/// <para>(Also see DirectX SDK: D2D1_GEOMETRY_SIMPLIFICATION_OPTION)</para>
///</summary>
public enum class GeometrySimplificationOption : Int32
{
    CubicsAndLines = D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES,
    Lines = D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
};

/// <summary>
/// <para>(Also see DirectX SDK: D2D1_BITMAP_INTERPOLATION_MODE)</para>
///</summary>
public enum class BitmapInterpolationMode : Int32
{

    /// <summary>
    /// Nearest Neighbor filtering. Also known as nearest pixel or nearest point sampling.
    /// </summary>
    NearestNeighbor = D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR,

    /// <summary>
    /// Linear filtering.
    /// </summary>
    Linear = D2D1_BITMAP_INTERPOLATION_MODE_LINEAR,
};

/// <summary>
/// This determines what gamma is used for interpolation/blending.
/// <para>(Also see DirectX SDK: D2D1_GAMMA)</para>
///</summary>
public enum class Gamma : Int32
{

    /// <summary>
    /// Colors are manipulated in 2.2 gamma color space.
    /// </summary>
    Gamma_22 = D2D1_GAMMA_2_2,

    /// <summary>
    /// Colors are manipulated in 1.0 gamma color space.
    /// </summary>
    Gamma_10 = D2D1_GAMMA_1_0,
};

/// <summary>
/// Specifies what the contents are of an opacity mask.
/// <para>(Also see DirectX SDK: D2D1_OPACITY_MASK_CONTENT)</para>
///</summary>
public enum class OpacityMaskContent : Int32
{

    /// <summary>
    /// The mask contains geometries or bitmaps.
    /// </summary>
    Graphics = D2D1_OPACITY_MASK_CONTENT_GRAPHICS,

    /// <summary>
    /// The mask contains text rendered using one of the natural text modes.
    /// </summary>
    TextNatural = D2D1_OPACITY_MASK_CONTENT_TEXT_NATURAL,

    /// <summary>
    /// The mask contains text rendered using one of the GDI compatible text modes.
    /// </summary>
    TextGdiCompatible = D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE,
};

/// <summary>
/// This enumeration describes the type of combine operation to be performed.
/// <para>(Also see DirectX SDK: D2D1_COMBINE_MODE)</para>
///</summary>
public enum class CombineMode : Int32
{

    /// <summary>
    /// Produce a geometry representing the set of points contained in either the first or
    /// the second geometry.
    /// </summary>
    Union = D2D1_COMBINE_MODE_UNION,

    /// <summary>
    /// Produce a geometry representing the set of points common to the first and the second
    /// geometries.
    /// </summary>
    Intersect = D2D1_COMBINE_MODE_INTERSECT,

    /// <summary>
    /// Produce a geometry representing the set of points contained in the first geometry
    /// or the second geometry, but not both.
    /// </summary>
    Xor = D2D1_COMBINE_MODE_XOR,

    /// <summary>
    /// Produce a geometry representing the set of points contained in the first geometry
    /// but not the second geometry.
    /// </summary>
    Exclude = D2D1_COMBINE_MODE_EXCLUDE,
};

/// <summary>
/// <para>(Also see DirectX SDK: D2D1_DASH_STYLE)</para>
///</summary>
public enum class DashStyle : Int32
{
    Solid = D2D1_DASH_STYLE_SOLID,
    Dash = D2D1_DASH_STYLE_DASH,
    Dot = D2D1_DASH_STYLE_DOT,
    DashDot = D2D1_DASH_STYLE_DASH_DOT,
    DashDotDot = D2D1_DASH_STYLE_DASH_DOT_DOT,
    Custom = D2D1_DASH_STYLE_CUSTOM,
};

/// <summary>
/// Indicates the debug level to be outputed by the debug layer.
/// <para>(Also see DirectX SDK: D2D1_DEBUG_LEVEL)</para>
///</summary>
public enum class DebugLevel : Int32
{
    None = D2D1_DEBUG_LEVEL_NONE,
    Error = D2D1_DEBUG_LEVEL_ERROR,
    Warning = D2D1_DEBUG_LEVEL_WARNING,
    Information = D2D1_DEBUG_LEVEL_INFORMATION,
};

/// <summary>
/// Modifications made to the draw text call that influence how the text is rendered.
/// <para>(Also see DirectX SDK: D2D1_DRAW_TEXT_OPTIONS)</para>
///</summary>
[Flags]
public enum class DrawTextOptions : Int32
{

    /// <summary>
    /// No Draw Text Options.
    /// </summary>
    None = D2D1_DRAW_TEXT_OPTIONS_NONE,

    /// <summary>
    /// Do not snap the baseline of the text vertically.
    /// </summary>
    NoSnap = D2D1_DRAW_TEXT_OPTIONS_NO_SNAP,

    /// <summary>
    /// Clip the text to the content bounds.
    /// </summary>
    Clip = 0x00000002

};

/// <summary>
/// Enum which descibes the manner in which we render edges of non-text primitives.
/// <para>(Also see DirectX SDK: D2D1_ANTIALIAS_MODE)</para>
///</summary>
public enum class AntialiasMode : Int32
{

    /// <summary>
    /// The edges of each primitive are antialiased sequentially.
    /// </summary>
    PerPrimitive = D2D1_ANTIALIAS_MODE_PER_PRIMITIVE,

    /// <summary>
    /// Each pixel is rendered if its pixel center is contained by the geometry.
    /// </summary>
    Aliased = D2D1_ANTIALIAS_MODE_ALIASED,
};

/// <summary>
/// Qualifies how alpha is to be treated in a bitmap or render target containing alpha.
/// <para>(Also see DirectX SDK: D2D1_ALPHA_MODE)</para>
///</summary>
public enum class AlphaMode : Int32
{

    /// <summary>
    /// Alpha mode should be determined implicitly. Some target surfaces do not supply or
    /// imply this information in which case alpha must be specified.
    /// </summary>
    Unknown = D2D1_ALPHA_MODE_UNKNOWN,

    /// <summary>
    /// Treat the alpha as premultipled.
    /// </summary>
    Premultiplied = D2D1_ALPHA_MODE_PREMULTIPLIED,

    /// <summary>
    /// Opacity is in the 'A' component only.
    /// </summary>
    Straight = D2D1_ALPHA_MODE_STRAIGHT,

    /// <summary>
    /// Ignore any alpha channel information.
    /// </summary>
    Ignore = D2D1_ALPHA_MODE_IGNORE,
};

/// <summary>
/// Enum which descibes how to sample from a source outside it's base tile.
/// <para>(Also see DirectX SDK: D2D1_EXTEND_MODE)</para>
///</summary>
public enum class ExtendMode : Int32
{

    /// <summary>
    /// Extend the edges of the source out by clamping sample points outside the source to
    /// the edges.
    /// </summary>
    Clamp = D2D1_EXTEND_MODE_CLAMP,

    /// <summary>
    /// The base tile is drawn untransformed and the remainder are filled by repeating the
    /// base tile.
    /// </summary>
    Wrap = D2D1_EXTEND_MODE_WRAP,

    /// <summary>
    /// The same as wrap, but alternate tiles are flipped The base tile is drawn untransformed.
    /// </summary>
    Mirror = D2D1_EXTEND_MODE_MIRROR,
};

/// <summary>
/// Specifies the threading model of the created factory and all of its derived resources.
/// <para>(Also see DirectX SDK: D2D1_FACTORY_TYPE)</para>
///</summary>
public enum class D2DFactoryType : Int32
{

    /// <summary>
    /// The resulting factory and derived resources may only be invoked serially. Reference
    /// counts on resources are interlocked, however, resource and render target state is
    /// not protected from multi-threaded access.
    /// </summary>
    SingleThreaded = D2D1_FACTORY_TYPE_SINGLE_THREADED,

    /// <summary>
    /// The resulting factory may be invoked from multiple threads. Returned resources use
    /// interlocked reference counting and their state is protected.
    /// </summary>
    MultiThreaded = D2D1_FACTORY_TYPE_MULTI_THREADED,
};

/// <summary>
/// Indicates whether the given figure is filled or hollow.
/// <para>(Also see DirectX SDK: D2D1_FIGURE_BEGIN)</para>
///</summary>
public enum class FigureBegin : Int32
{
    Filled = D2D1_FIGURE_BEGIN_FILLED,
    Hollow = D2D1_FIGURE_BEGIN_HOLLOW,
};

/// <summary>
/// Indicates whether the figure is open or closed on its end point.
/// <para>(Also see DirectX SDK: D2D1_FIGURE_END)</para>
///</summary>
public enum class FigureEnd : Int32
{
    Open = D2D1_FIGURE_END_OPEN,
    Closed = D2D1_FIGURE_END_CLOSED,
};

/// <summary>
/// <para>(Also see DirectX SDK: D2D1_GEOMETRY_RELATION)</para>
///</summary>
public enum class GeometryRelation : Int32
{

    /// <summary>
    /// The relation between the geometries couldn't be determined. This value is never returned
    /// by any D2D method.
    /// </summary>
    Unknown = D2D1_GEOMETRY_RELATION_UNKNOWN,

    /// <summary>
    /// The two geometries do not intersect at all.
    /// </summary>
    Disjoint = D2D1_GEOMETRY_RELATION_DISJOINT,

    /// <summary>
    /// The passed in geometry is entirely contained by the object.
    /// </summary>
    IsContained = D2D1_GEOMETRY_RELATION_IS_CONTAINED,

    /// <summary>
    /// The object entirely contains the passed in geometry.
    /// </summary>
    Contains = D2D1_GEOMETRY_RELATION_CONTAINS,

    /// <summary>
    /// The two geometries overlap but neither completely contains the other.
    /// </summary>
    Overlap = D2D1_GEOMETRY_RELATION_OVERLAP,
};

/// <summary>
/// Indicates whether the given segment should be stroked, or, if the join between this
/// segment and the previous one should be smooth.
/// <para>(Also see DirectX SDK: D2D1_PATH_SEGMENT)</para>
///</summary>
[Flags]
public enum class PathSegment : Int32
{
    None = D2D1_PATH_SEGMENT_NONE,
    ForceUnstroked = D2D1_PATH_SEGMENT_FORCE_UNSTROKED,
    ForceRoundLineJoin = D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN,
};

/// <summary>
/// Enum which descibes the drawing of the ends of a line.
/// <para>(Also see DirectX SDK: D2D1_CAP_STYLE)</para>
///</summary>
public enum class CapStyle : Int32
{

    /// <summary>
    /// Flat line cap.
    /// </summary>
    Flat = D2D1_CAP_STYLE_FLAT,

    /// <summary>
    /// Square line cap.
    /// </summary>
    Square = D2D1_CAP_STYLE_SQUARE,

    /// <summary>
    /// Round line cap.
    /// </summary>
    Round = D2D1_CAP_STYLE_ROUND,

    /// <summary>
    /// Triangle line cap.
    /// </summary>
    Triangle = D2D1_CAP_STYLE_TRIANGLE,
};

/// <summary>
/// Specified options that can be applied when a layer resource is applied to create
/// a layer.
/// <para>(Also see DirectX SDK: D2D1_LAYER_OPTIONS)</para>
///</summary>
[Flags]
public enum class LayerOptions : Int32
{
    None = D2D1_LAYER_OPTIONS_NONE,

    /// <summary>
    /// The layer will render correctly for ClearType text. If the render target was set
    /// to ClearType previously, the layer will continue to render ClearType. If the render
    /// target was set to ClearType and this option is not specified, the render target
    /// will be set to render gray-scale until the layer is popped. The caller can override
    /// this default by calling SetTextAntialiasMode while within the layer. This flag is
    /// slightly slower than the default.
    /// </summary>
    InitializeForClearType = D2D1_LAYER_OPTIONS_INITIALIZE_FOR_CLEARTYPE,
};

/// <summary>
/// Enum which descibes the drawing of the corners on the line.
/// <para>(Also see DirectX SDK: D2D1_LINE_JOIN)</para>
///</summary>
public enum class LineJoin : Int32
{

    /// <summary>
    /// Miter join.
    /// </summary>
    Miter = D2D1_LINE_JOIN_MITER,

    /// <summary>
    /// Bevel join.
    /// </summary>
    Bevel = D2D1_LINE_JOIN_BEVEL,

    /// <summary>
    /// Round join.
    /// </summary>
    Round = D2D1_LINE_JOIN_ROUND,

    /// <summary>
    /// Miter/Bevel join.
    /// </summary>
    MiterOrBevel = D2D1_LINE_JOIN_MITER_OR_BEVEL,
};

/// <summary>
/// Describes how present should behave.
/// <para>(Also see DirectX SDK: D2D1_PRESENT_OPTIONS)</para>
///</summary>
[Flags]
public enum class PresentOptions : Int32
{
    None = D2D1_PRESENT_OPTIONS_NONE,

    /// <summary>
    /// Keep the target contents intact through present.
    /// </summary>
    RetainContents = D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS,

    /// <summary>
    /// Do not wait for display refresh to commit changes to display.
    /// </summary>
    Immediately = D2D1_PRESENT_OPTIONS_IMMEDIATELY,
};

/// <summary>
/// <para>(Also see DirectX SDK: D2D1_RENDER_TARGET_USAGE)</para>
///</summary>
[FlagsAttribute]
public enum class RenderTargetUsage : Int32
{
    None = D2D1_RENDER_TARGET_USAGE_NONE,

    /// <summary>
    /// Rendering will occur locally, if a terminal-services session is established, the
    /// bitmap updates will be sent to the terminal services client.
    /// </summary>
    ForceBitmapRemoting = D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING,

    /// <summary>
    /// The render target will allow a call to GetDC on the IGdiInteropRenderTarget interface.
    /// Rendering will also occur locally.
    /// </summary>
    GdiCompatible = D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE,
};

/// <summary>
/// <para>(Also see DirectX SDK: D2D1_RENDER_TARGET_TYPE)</para>
///</summary>
public enum class RenderTargetType : Int32
{

    /// <summary>
    /// D2D is free to choose the render target type for the caller.
    /// </summary>
    Default = D2D1_RENDER_TARGET_TYPE_DEFAULT,

    /// <summary>
    /// The render target will render using the CPU.
    /// </summary>
    Software = D2D1_RENDER_TARGET_TYPE_SOFTWARE,

    /// <summary>
    /// The render target will render using the GPU.
    /// </summary>
    Hardware = D2D1_RENDER_TARGET_TYPE_HARDWARE,
};

/// <summary>
/// <para>(Also see DirectX SDK: D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS)</para>
///</summary>
[Flags]
public enum class CompatibleRenderTargetOptions : Int32
{
    None = D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE,

    /// <summary>
    /// The compatible render target will allow a call to GetDC on the IGdiInteropRenderTarget
    /// interface. This can be specified even if the parent render target is not GDI compatible.
    /// </summary>
    GdiCompatible = D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE,
};

/// <summary>
/// <para>(Also see DirectX SDK: D2D1_SWEEP_DIRECTION)</para>
///</summary>
public enum class SweepDirection : Int32
{
    CounterClockwise = D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE,
    Clockwise = D2D1_SWEEP_DIRECTION_CLOCKWISE,
};

/// <summary>
/// <para>(Also see DirectX SDK: D2D1_TEXT_ANTIALIAS_MODE)</para>
///</summary>
public enum class TextAntialiasMode : Int32
{

    /// <summary>
    /// Render text using the current system setting.
    /// </summary>
    Default = D2D1_TEXT_ANTIALIAS_MODE_DEFAULT,

    /// <summary>
    /// Render text using ClearType.
    /// </summary>
    ClearType = D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE,

    /// <summary>
    /// Render text using gray-scale.
    /// </summary>
    Grayscale = D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE,

    /// <summary>
    /// Render text aliased.
    /// </summary>
    Aliased = D2D1_TEXT_ANTIALIAS_MODE_ALIASED,
};

/// <summary>
/// <para>(Also see DirectX SDK: D2D1_FILL_MODE)</para>
///</summary>
public enum class FillMode : Int32
{
    Alternate = D2D1_FILL_MODE_ALTERNATE,
    Winding = D2D1_FILL_MODE_WINDING,
};

/// <summary>
/// <para>(Also see DirectX SDK: D2D1_WINDOW_STATE)</para>
///</summary>
[Flags]
public enum class WindowState : Int32
{
    None = D2D1_WINDOW_STATE_NONE,
    Occluded = D2D1_WINDOW_STATE_OCCLUDED,
};

/// <summary>
/// <para>(Also see DirectX SDK: D2D1_DC_INITIALIZE_MODE)</para>
///</summary>
public enum class DcInitializeMode : Int32
{

    /// <summary>
    /// The contents of the D2D render target will be copied to the DC.
    /// </summary>
    Copy = D2D1_DC_INITIALIZE_MODE_COPY,

    /// <summary>
    /// The contents of the DC will be cleared.
    /// </summary>
    Clear = D2D1_DC_INITIALIZE_MODE_CLEAR,
};


} } } }

